/**
 * Created with Intellij IDEA.
 * Description:
 * User: 28318
 * Date: 2025-10-31
 * Time: 16:13
 */

import java.util.List;

/**
 * 主程序类，处理用户交互和菜单显示
 */
public class Main {
    private static final int RESOURCE_TYPES = 3; // 固定3类资源R1、R2、R3
    private SystemState systemState;
    private BankersAlgorithm bankersAlgorithm;
    private InputHandler inputHandler;

    public Main() {
        bankersAlgorithm = new BankersAlgorithm();
        inputHandler = new InputHandler();
    }

    // 初始化系统状态
    public void initialize() {
        System.out.println("===== 初始化系统 =====");
        int choice = inputHandler.readInt("请选择初始化方式（1-默认数据，2-手动输入）：\n", 1, 2);

        if (choice == 1) {
            // 使用默认数据初始化
            initDefaultData();
        } else {
            // 手动输入数据初始化
            initManualData();
        }

        // 计算需求矩阵
        systemState.calculateNeed();
        System.out.println("系统初始化完成！");
    }

    // 使用默认数据初始化
    private void initDefaultData() {
        int n = 5; // 5个进程
        systemState = new SystemState(n, RESOURCE_TYPES);

        // 资源总数 R1=10, R2=5, R3=7
        int[] totalResources = {10, 5, 7};

        // 最大需求矩阵
        int[][] max = {
                {7, 5, 3},
                {3, 2, 2},
                {9, 0, 2},
                {2, 2, 2},
                {4, 3, 3}
        };

        // 已分配矩阵
        int[][] allocation = {
                {0, 1, 0},
                {2, 0, 0},
                {3, 0, 2},
                {2, 1, 1},
                {0, 0, 2}
        };

        // 计算可用资源 = 总资源 - 已分配资源总和
        int[] available = calculateAvailable(totalResources, allocation, n);

        systemState.setMax(max);
        systemState.setAllocation(allocation);
        systemState.setAvailable(available);
    }

    // 手动输入数据初始化
    private void initManualData() {
        int n = inputHandler.readInt("请输入进程数量（3-5）：\n", 3, 5);
        systemState = new SystemState(n, RESOURCE_TYPES);

        // 输入总资源
        int[] totalResources = inputHandler.readResourceArray(
                "请输入系统总资源数量（R1 R2 R3）：\n", RESOURCE_TYPES);

        // 输入最大需求矩阵
        int[][] max = inputHandler.readMatrix("最大需求Max", n, RESOURCE_TYPES);

        // 输入已分配矩阵
        int[][] allocation = inputHandler.readMatrix("已分配Allocation", n, RESOURCE_TYPES);

        // 检查分配是否超过最大需求
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < RESOURCE_TYPES; j++) {
                if (allocation[i][j] > max[i][j]) {
                    System.out.println("错误：进程P" + i + "的已分配资源R" + (j+1) +
                            "超过最大需求！请重新初始化。");
                    initManualData();
                    return;
                }
            }
        }

        // 计算可用资源 = 总资源 - 已分配资源总和
        int[] available = calculateAvailable(totalResources, allocation, n);

        // 检查可用资源是否为负数
        for (int j = 0; j < RESOURCE_TYPES; j++) {
            if (available[j] < 0) {
                System.out.println("错误：已分配资源总和超过系统总资源！请重新初始化。");
                initManualData();
                return;
            }
        }

        systemState.setMax(max);
        systemState.setAllocation(allocation);
        systemState.setAvailable(available);
    }

    // 计算可用资源
    private int[] calculateAvailable(int[] total, int[][] allocation, int n) {
        int[] available = total.clone();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < RESOURCE_TYPES; j++) {
                available[j] -= allocation[i][j];
            }
        }
        return available;
    }

    // 显示菜单并处理用户选择
    public void showMenu() {
        while (true) {
            System.out.println("\n===== 银行家算法模拟系统 =====");
            System.out.println("1. 显示当前系统状态");
            System.out.println("2. 执行安全序列检查");
            System.out.println("3. 处理资源请求");
            System.out.println("4. 退出程序");
            System.out.println("=============================");

            int choice = inputHandler.readInt("请选择操作：\n", 1, 4);

            switch (choice) {
                case 1:
                    systemState.displayState();
                    break;
                case 2:
                    checkSafeSequence();
                    break;
                case 3:
                    handleResourceRequest();
                    break;
                case 4:
                    System.out.println("程序已退出！");
                    inputHandler.close();
                    return;
            }
        }
    }

    // 检查安全序列
    private void checkSafeSequence() {
        System.out.println("\n===== 安全序列检查 =====");
        List<Integer> safeSequence = bankersAlgorithm.isSafe(systemState);

        if (safeSequence != null) {
            System.out.println("系统处于安全状态！");
            System.out.println("安全序列为：" + bankersAlgorithm.safeSequenceToString(safeSequence));
        } else {
            System.out.println("系统当前处于不安全状态！");
        }
    }

    // 处理资源请求
    private void handleResourceRequest() {
        System.out.println("\n===== 处理资源请求 =====");
        int processId = inputHandler.readInt("请输入请求资源的进程号（0-" + (systemState.getN() - 1) + "）：",
                0, systemState.getN() - 1);

        int[] request = inputHandler.readResourceArray(
                "请输入请求的资源数量（R1 R2 R3）：\n", RESOURCE_TYPES);

        bankersAlgorithm.requestResource(systemState, processId, request);
    }

    // 主函数
    public static void main(String[] args) {
        Main main = new Main();
        main.initialize();
        main.showMenu();
    }
}